ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಇಂಟಿಗ್ರೇಷನ್: ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಟೈಪ್ ಸೇಫ್ಟಿ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯ ಒಂದು ಮೂಲಾಧಾರವಾಗಿದೆ, ಇದು ಕೋಡ್ ಗುಣಮಟ್ಟ, ನಿರ್ವಹಣೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಹೆಚ್ಚಿಸುವ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. ಜನಪ್ರಿಯ Node.js ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆದ Express.js ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮ ಬ್ಯಾಕೆಂಡ್ API ಗಳ ದೃಢತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು Express.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಸಾಧಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ, ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ APIಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

Express.js ನಲ್ಲಿ ಟೈಪ್ ಸೇಫ್ಟಿ ಏಕೆ ಮುಖ್ಯ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಡೈನಾಮಿಕ್ ಭಾಷೆಗಳಲ್ಲಿ, ದೋಷಗಳು ಸಾಮಾನ್ಯವಾಗಿ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಕಂಡುಬರುತ್ತವೆ, ಇದು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಕಷ್ಟಕರವಾದ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ಪರಿಚಯಿಸುವ ಮೂಲಕ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ, ಉತ್ಪಾದನೆಗೆ ಹೋಗುವ ಮೊದಲು ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. Express.js ಸಂದರ್ಭದಲ್ಲಿ, ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು, ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಮತ್ತು ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಿಗೆ ಟೈಪ್ ಸೇಫ್ಟಿ ವಿಶೇಷವಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಈ ಅಂಶಗಳ ತಪ್ಪಾದ ನಿರ್ವಹಣೆಯು ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್‌ಗಳು, ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ ಮತ್ತು ಭದ್ರತಾ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

• ಮುಂಚಿತವಾಗಿ ದೋಷ ಪತ್ತೆ: ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಟೈಪ್-ಸಂಬಂಧಿತ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಿ, ರನ್‌ಟೈಮ್ ಆಶ್ಚರ್ಯಗಳ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ಕೋಡ್ ನಿರ್ವಹಣೆ: ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಸುಲಭಗೊಳಿಸುತ್ತವೆ.
• ವರ್ಧಿತ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಟೂಲಿಂಗ್: IDEಗಳು ಟೈಪ್ ಮಾಹಿತಿಯೊಂದಿಗೆ ಉತ್ತಮ ಸಲಹೆಗಳನ್ನು ಮತ್ತು ದೋಷ ಪರಿಶೀಲನೆಯನ್ನು ಒದಗಿಸಬಹುದು.
• ಕಡಿಮೆ ದೋಷಗಳು: ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ತಪ್ಪಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ರವಾನಿಸುವಂತಹ ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಟೈಪ್ ಸೇಫ್ಟಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ Express.js ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು

ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಟೈಪ್ ಸೇಫ್ಟಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಮೂಲಭೂತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ Express.js ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸೋಣ. ಇದು ನಮ್ಮ ಉದಾಹರಣೆಗಳಿಗೆ ಅಡಿಪಾಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು

• Node.js ಮತ್ತು npm (ನೋಡ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್) ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ನೀವು ಅವುಗಳನ್ನು ಅಧಿಕೃತ Node.js ವೆಬ್‌ಸೈಟ್‌ನಿಂದ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು. ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಗಾಗಿ ನೀವು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿರುವಿರಾ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್‌ನಂತಹ ಕೋಡ್ ಎಡಿಟರ್, ಇದು ಅತ್ಯುತ್ತಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆ.

ಪ್ರಾಜೆಕ್ಟ್ ಪ್ರಾರಂಭ

1. ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ: mkdir typescript-express-app && cd typescript-express-app
2. ಹೊಸ npm ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ: npm init -y
3. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು Express.js ಅನ್ನು ಸ್ಥಾಪಿಸಿ: npm install typescript express
4. Express.js ಗಾಗಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿ (ಟೈಪ್ ಸೇಫ್ಟಿಗಾಗಿ ಮುಖ್ಯ): npm install @types/express @types/node
5. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ: npx tsc --init (ಇದು tsconfig.json ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ.)

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು

tsconfig.json ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ಸೂಕ್ತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿ. ಮಾದರಿ ಕಾನ್ಫಿಗರೇಶನ್ ಇಲ್ಲಿದೆ:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

ಗಮನಿಸಬೇಕಾದ ಪ್ರಮುಖ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು:

• target: ECMAScript ಟಾರ್ಗೆಟ್ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. es6 ಉತ್ತಮ ಆರಂಭಿಕ ಹಂತವಾಗಿದೆ.
• module: ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಉತ್ಪಾದನೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. commonjs Node.js ಗಾಗಿ ಸಾಮಾನ್ಯ ಆಯ್ಕೆಯಾಗಿದೆ.
• outDir: ಕಂಪೈಲ್ ಮಾಡಿದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳಿಗಾಗಿ ಔಟ್‌ಪುಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• rootDir: ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲ ಫೈಲ್‌ಗಳ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• strict: ವರ್ಧಿತ ಟೈಪ್ ಸೇಫ್ಟಿಗಾಗಿ ಎಲ್ಲಾ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್-ಚೆಕಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದನ್ನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
• esModuleInterop: CommonJS ಮತ್ತು ES ಮಾಡ್ಯೂಲ್‌ಗಳ ನಡುವೆ ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯತೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ಎಂಟ್ರಿ ಪಾಯಿಂಟ್ ರಚಿಸುವುದು

src ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ ಮತ್ತು index.ts ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿ:

mkdir src
touch src/index.ts

src/index.ts ಅನ್ನು ಮೂಲಭೂತ Express.js ಸರ್ವರ್ ಸೆಟಪ್‌ನೊಂದಿಗೆ ಭರ್ತಿ ಮಾಡಿ:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, TypeScript Express!');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಬಿಲ್ಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಸೇರಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ನಿಮ್ಮ package.json ಫೈಲ್‌ಗೆ ಬಿಲ್ಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಸೇರಿಸಿ:

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js",
  "dev": "npm run build && npm run start"
}

ಈಗ ನೀವು ಸರ್ವರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪ್ರಾರಂಭಿಸಲು npm run dev ಅನ್ನು ಚಲಾಯಿಸಬಹುದು.

ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಟೈಪ್ ಸೇಫ್ಟಿ: ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಟೈಪ್ ಸೇಫ್ಟಿಯ ತಿರುಳು Request ಮತ್ತು Response ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪ್ರಕಾರಗಳನ್ನು ಸರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವುದರಲ್ಲಿದೆ. Express.js ಈ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಜೆನೆರಿಕ್ ಪ್ರಕಾರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು, ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿ, ಮತ್ತು ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಮೂಲಭೂತ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಪ್ರಕಾರಗಳು

ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಹೆಸರನ್ನು ನಿರೀಕ್ಷಿಸುವ ಸರಳ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface NameQuery {
  name: string;
}

app.get('/hello', (req: Request, res: Response) => {
  const name = req.query.name;

  if (!name) {
    return res.status(400).send('Name parameter is required.');
  }

  res.send(`Hello, ${name}!`);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• Request<any, any, any, NameQuery> ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
• ಮೊದಲ any ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, /users/:id).
• ಎರಡನೇ any ರೆಸ್ಪಾನ್ಸ್ ಬಾಡಿ ಪ್ರಕಾರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• ಮೂರನೇ any ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿ ಪ್ರಕಾರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• NameQuery ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ.

NameQuery ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈಗ req.query.name ಪ್ರಾಪರ್ಟಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಮತ್ತು ಅದು string ಪ್ರಕಾರದ್ದಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಬಹುದು. ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಅಥವಾ ತಪ್ಪಾದ ಪ್ರಕಾರದ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೋಷವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ರೂಟ್‌ಗಳಿಗೆ (ಉದಾ., POST, PUT, PATCH), ನೀವು ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಾಗಿ ಒಂದು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು Request ಪ್ರಕಾರದಲ್ಲಿ ಬಳಸಬಹುದು:

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json()); // Important for parsing JSON request bodies

interface CreateUserRequest {
  firstName: string;
  lastName: string;
  email: string;
}

app.post('/users', (req: Request, res: Response) => {
  const { firstName, lastName, email } = req.body;

  // Validate the request body
  if (!firstName || !lastName || !email) {
    return res.status(400).send('Missing required fields.');
  }

  // Process the user creation (e.g., save to database)
  console.log(`Creating user: ${firstName} ${lastName} (${email})`);

  res.status(201).send('User created successfully.');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• CreateUserRequest ನಿರೀಕ್ಷಿತ ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಯ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
• app.use(bodyParser.json()) JSON ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಅದು ಇಲ್ಲದಿದ್ದರೆ, req.body ಅನಿರ್ದಿಷ್ಟವಾಗಿರುತ್ತದೆ.
• Request ಪ್ರಕಾರವು ಈಗ Request<any, any, CreateUserRequest> ಆಗಿದೆ, ಇದು ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಯು CreateUserRequest ಇಂಟರ್ಫೇಸ್‌ಗೆ ಅನುಗುಣವಾಗಿರಬೇಕು ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈಗ req.body ಆಬ್ಜೆಕ್ಟ್ ನಿರೀಕ್ಷಿತ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು (firstName, lastName, ಮತ್ತು email) ಹೊಂದಿದೆ ಮತ್ತು ಅವುಗಳ ಪ್ರಕಾರಗಳು ಸರಿಯಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ತಪ್ಪಾದ ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿ ಡೇಟಾದಿಂದ ಉಂಟಾಗುವ ರನ್‌ಟೈಮ್ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ರೂಟ್‌ಗಳಿಗೆ (ಉದಾ., /users/:id), ನೀವು ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗಾಗಿ ಒಂದು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು Request ಪ್ರಕಾರದಲ್ಲಿ ಬಳಸಬಹುದು:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface UserParams {
  id: string;
}

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users/:id', (req: Request, res: Response) => {
  const userId = req.params.id;

  const user = users.find(u => u.id === userId);

  if (!user) {
    return res.status(404).send('User not found.');
  }

  res.json(user);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• UserParams ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, id ಪ್ಯಾರಾಮೀಟರ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿರಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• Request ಪ್ರಕಾರವು ಈಗ Request<UserParams> ಆಗಿದೆ, ಇದು req.params ಆಬ್ಜೆಕ್ಟ್ UserParams ಇಂಟರ್ಫೇಸ್‌ಗೆ ಅನುಗುಣವಾಗಿರಬೇಕು ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈಗ req.params.id ಪ್ರಾಪರ್ಟಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಮತ್ತು ಅದು string ಪ್ರಕಾರದ್ದಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ರೂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದರಿಂದ ಅಥವಾ ಅವುಗಳನ್ನು ತಪ್ಪಾದ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಬಳಸುವುದರಿಂದ ಉಂಟಾಗುವ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ರೆಸ್ಪಾನ್ಸ್ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು

ರಿಕ್ವೆಸ್ಟ್ ಟೈಪ್ ಸೇಫ್ಟಿಯ ಮೇಲೆ ಗಮನಹರಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದ್ದರೂ, ರೆಸ್ಪಾನ್ಸ್ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಕೋಡ್ ಸ್ಪಷ್ಟತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಅಸಂಗತತೆಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನೀವು ರೆಸ್ಪಾನ್ಸ್‌ನಲ್ಲಿ ಕಳುಹಿಸುತ್ತಿರುವ ಡೇಟಾದ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users', (req: Request, res: Response) => {
    res.json(users);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಇಲ್ಲಿ, Response<User[]> ರೆಸ್ಪಾನ್ಸ್ ಬಾಡಿಯು User ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇ ಆಗಿರಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ API ರೆಸ್ಪಾನ್ಸ್‌ಗಳಲ್ಲಿ ನೀವು ಸ್ಥಿರವಾಗಿ ಸರಿಯಾದ ಡೇಟಾ ರಚನೆಯನ್ನು ಕಳುಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನೀವು `User[]` ಪ್ರಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿರದ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.

ಮಿಡಲ್‌ವೇರ್ ಟೈಪ್ ಸೇಫ್ಟಿ

Express.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಕ್ರಾಸ್-ಕಟಿಂಗ್ ಕನ್ಸರ್ನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್‌ಗಳು ಅತ್ಯಗತ್ಯ. ಮಿಡಲ್‌ವೇರ್‌ನಲ್ಲಿ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿನಷ್ಟೇ ಮುಖ್ಯವಾಗಿದೆ.

ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಟೈಪ್ ಮಾಡುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್‌ನ ಮೂಲಭೂತ ರಚನೆಯು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನಂತೆಯೇ ಇರುತ್ತದೆ:

import express, { Request, Response, NextFunction } from 'express';

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Authentication logic
  const isAuthenticated = true; // Replace with actual authentication check

  if (isAuthenticated) {
    next(); // Proceed to the next middleware or route handler
  } else {
    res.status(401).send('Unauthorized');
  }
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, authenticated user!');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• NextFunction ಎಂಬುದು Express.js ಒದಗಿಸಿದ ಒಂದು ಪ್ರಕಾರವಾಗಿದ್ದು, ಅದು ಸರಪಳಿಯಲ್ಲಿನ ಮುಂದಿನ ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• ಮಿಡಲ್‌ವೇರ್ ಫಂಕ್ಷನ್ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಂತೆಯೇ Request ಮತ್ತು Response ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ವಿಸ್ತರಿಸುವುದು

ಕೆಲವೊಮ್ಮೆ, ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್‌ನಲ್ಲಿ Request ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಕಸ್ಟಮ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸಲು ನೀವು ಬಯಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ದೃಢೀಕರಣ ಮಿಡಲ್‌ವೇರ್ ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ user ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಬಹುದು. ಇದನ್ನು ಟೈಪ್-ಸೇಫ್ ರೀತಿಯಲ್ಲಿ ಮಾಡಲು, ನೀವು Request ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಬೇಕಾಗುತ್ತದೆ.

import express, { Request, Response, NextFunction } from 'express';

interface User {
  id: string;
  username: string;
  email: string;
}

// Augment the Request interface
declare global {
  namespace Express {
    interface Request {
      user?: User;
    }
  }
}

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Authentication logic (replace with actual authentication check)
  const user: User = { id: '123', username: 'johndoe', email: 'john.doe@example.com' };
  req.user = user; // Add the user to the request object
  next(); // Proceed to the next middleware or route handler
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  const username = req.user?.username || 'Guest';
  res.send(`Hello, ${username}!`);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• Express.Request ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ನಾವು ಗ್ಲೋಬಲ್ ಡಿಕ್ಲರೇಶನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
• ನಾವು Request ಇಂಟರ್ಫೇಸ್‌ಗೆ User ಪ್ರಕಾರದ ಐಚ್ಛಿಕ user ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ.
• ಈಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೂರು ನೀಡದೆ ನಿಮ್ಮ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ req.user ಪ್ರಾಪರ್ಟಿಯನ್ನು ನೀವು ಪ್ರವೇಶಿಸಬಹುದು. `req.user?.username` ನಲ್ಲಿರುವ `?` ಬಳಕೆದಾರ ದೃಢೀಕರಣಗೊಳ್ಳದ ಸಂದರ್ಭಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಇದು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಇಂಟಿಗ್ರೇಷನ್‌ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನಿಮ್ಮ Express.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ:

• ಸ್ಟ್ರಿಕ್ಟ್ ಮೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ: ಎಲ್ಲಾ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್-ಚೆಕಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ನಿಮ್ಮ tsconfig.json ಫೈಲ್‌ನಲ್ಲಿ "strict": true ಆಯ್ಕೆಯನ್ನು ಬಳಸಿ. ಇದು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಉನ್ನತ ಮಟ್ಟದ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಟೈಪ್ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಡೇಟಾದ ರಚನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಟೈಪ್ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲದು ಮಾಡುತ್ತದೆ.
• ಜೆನೆರಿಕ್ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿ: ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಜೆನೆರಿಕ್ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಿ.
• ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ: ನಿಮ್ಮ ಕೋಡ್‌ನ ಸರಿಯಾಗಿರುವುದನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳು ನಿಖರವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಿರಿ. ಕೋಡ್ ಗುಣಮಟ್ಟವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಪರೀಕ್ಷೆ ಮಾಡುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ಲಿಂಟರ್ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟರ್ ಬಳಸಿ: ಸ್ಥಿರವಾದ ಕೋಡಿಂಗ್ ಶೈಲಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಮತ್ತು ಸಂಭಾವ್ಯ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಲಿಂಟರ್ (ESLint ನಂತಹ) ಮತ್ತು ಫಾರ್ಮ್ಯಾಟರ್ (Prettier ನಂತಹ) ಬಳಸಿ.
• any ಪ್ರಕಾರವನ್ನು ತಪ್ಪಿಸಿ: any ಪ್ರಕಾರದ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ, ಏಕೆಂದರೆ ಇದು ಟೈಪ್ ಚೆಕಿಂಗ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವ ಉದ್ದೇಶವನ್ನು ವಿಫಲಗೊಳಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣವಾಗಿ ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಅದನ್ನು ಬಳಸಿ, ಮತ್ತು ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಗಳು ಅಥವಾ ಜೆನೆರಿಕ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ತಾರ್ಕಿಕವಾಗಿ ರಚಿಸಿ: ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಕಾರ್ಯಚಟುವಟಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಥವಾ ಫೋಲ್ಡರ್‌ಗಳಾಗಿ ಆಯೋಜಿಸಿ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ವಹಣೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಬಳಸಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಕಂಟೇನರ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಪರೀಕ್ಷಿಸಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲದು ಮಾಡಬಹುದು. InversifyJS ನಂತಹ ಲೈಬ್ರರಿಗಳು ಜನಪ್ರಿಯ ಆಯ್ಕೆಗಳಾಗಿವೆ.

Express.js ಗಾಗಿ ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಕಲ್ಪನೆಗಳು

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಡೆಕೋರೇಟರ್‌ಗಳು ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. Express.js ನಲ್ಲಿ ರೂಟ್ ನೋಂದಣಿಯನ್ನು ಸರಳಗೊಳಿಸಲು ನೀವು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ಮೊದಲು, ನಿಮ್ಮ tsconfig.json ಫೈಲ್‌ನಲ್ಲಿ compilerOptions ಗೆ "experimentalDecorators": true ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಪ್ರಾಯೋಗಿಕ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು.

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "experimentalDecorators": true
  }
}

ನಂತರ, ರೂಟ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸಲು ನೀವು ಕಸ್ಟಮ್ ಡೆಕೋರೇಟರ್ ಅನ್ನು ರಚಿಸಬಹುದು:

import express, { Router, Request, Response } from 'express';

function route(method: string, path: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    if (!target.__router__) {
      target.__router__ = Router();
    }

    target.__router__[method](path, descriptor.value);
  };
}

class UserController {
  @route('get', '/users')
  getUsers(req: Request, res: Response) {
    res.send('List of users');
  }

  @route('post', '/users')
  createUser(req: Request, res: Response) {
    res.status(201).send('User created');
  }

  public getRouter() {
    return this.__router__;
  }
}

const userController = new UserController();

const app = express();
const port = 3000;

app.use('/', userController.getRouter());

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• route ಡೆಕೋರೇಟರ್ HTTP ವಿಧಾನ ಮತ್ತು ಪಥವನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
• ಇದು ಅಲಂಕರಿಸಿದ ವಿಧಾನವನ್ನು ಕ್ಲಾಸ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿತವಾದ ರೂಟರ್‌ನಲ್ಲಿ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಆಗಿ ನೋಂದಾಯಿಸುತ್ತದೆ.
• ಇದು ರೂಟ್ ನೋಂದಣಿಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲದು ಮಾಡುತ್ತದೆ.

ಕಸ್ಟಮ್ ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ವ್ಯಾಪ್ತಿಯೊಳಗೆ ವೇರಿಯಬಲ್‌ನ ಪ್ರಕಾರವನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಗಳು ಅಥವಾ ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ನೀವು ಕಸ್ಟಮ್ ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

interface Product {
    id: string;
    name: string;
    price: number;
}

function isProduct(obj: any): obj is Product {
    return typeof obj === 'object' &&
           obj !== null &&
           typeof obj.id === 'string' &&
           typeof obj.name === 'string' &&
           typeof obj.price === 'number';
}

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json());

app.post('/products', (req: Request, res: Response) => {
    if (!isProduct(req.body)) {
        return res.status(400).send('Invalid product data');
    }

    const product: Product = req.body;
    console.log(`Creating product: ${product.name}`);
    res.status(201).send('Product created');
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• isProduct ಫಂಕ್ಷನ್ ಒಂದು ಕಸ್ಟಮ್ ಟೈಪ್ ಗಾರ್ಡ್ ಆಗಿದ್ದು, ಅದು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ Product ಇಂಟರ್ಫೇಸ್‌ಗೆ ಅನುಗುಣವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
• /products ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನೊಳಗೆ, ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು isProduct ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
• ರಿಕ್ವೆಸ್ಟ್ ಬಾಡಿಯು ಮಾನ್ಯವಾದ ಉತ್ಪನ್ನವಾಗಿದ್ದರೆ, if ಬ್ಲಾಕ್‌ನೊಳಗೆ req.body ಯು Product ಪ್ರಕಾರದ್ದಾಗಿದೆ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿದಿರುತ್ತದೆ.

API ವಿನ್ಯಾಸದಲ್ಲಿ ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳನ್ನು ತಿಳಿಸುವುದು

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ APIಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ಪ್ರವೇಶಸಾಧ್ಯತೆ, ಉಪಯುಕ್ತತೆ ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಹಲವಾರು ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಬೇಕು.

• ಸ್ಥಳೀಕರಣ ಮತ್ತು ಅಂತರಾಷ್ಟ್ರೀಕರಣ (i18n ಮತ್ತು L10n):
  • ವಿಷಯ ಸಂಧಾನ: Accept-Language ಹೆಡರ್ ಆಧಾರದ ಮೇಲೆ ವಿಷಯ ಸಂಧಾನದ ಮೂಲಕ ಬಹು ಭಾಷೆಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳನ್ನು ಬೆಂಬಲಿಸಿ.
  • ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಫಾರ್ಮ್ಯಾಟಿಂಗ್: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿನ ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತಪ್ಪಿಸಲು ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕಾಗಿ ISO 8601 ಫಾರ್ಮ್ಯಾಟ್ ಬಳಸಿ.
  • ಸಂಖ್ಯೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್: ಬಳಕೆದಾರರ ಲೊಕೇಲ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಸಂಖ್ಯೆ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸಿ (ಉದಾಹರಣೆಗೆ, ದಶಮಾಂಶ ವಿಭಜಕಗಳು ಮತ್ತು ಸಾವಿರ ವಿಭಜಕಗಳು).
  • ಕರೆನ್ಸಿ ನಿರ್ವಹಣೆ: ಬಹು ಕರೆನ್ಸಿಗಳನ್ನು ಬೆಂಬಲಿಸಿ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಲ್ಲಿ ವಿನಿಮಯ ದರ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಿ.
  • ಪಠ್ಯ ನಿರ್ದೇಶನ: ಅರೇಬಿಕ್ ಮತ್ತು ಹೀಬ್ರೂನಂತಹ ಬಲದಿಂದ ಎಡಕ್ಕೆ (RTL) ಭಾಷೆಗಳಿಗೆ ಅವಕಾಶ ಕಲ್ಪಿಸಿ.
• ಸಮಯ ವಲಯಗಳು:
  • ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು UTC (ಸಮನ್ವಯ ಸಾರ್ವತ್ರಿಕ ಸಮಯ) ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ.
  • ಬಳಕೆದಾರರಿಗೆ ತಮ್ಮ ಆದ್ಯತೆಯ ಸಮಯ ವಲಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಮತ್ತು ಕ್ಲೈಂಟ್ ಬದಿಯಲ್ಲಿ ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಪರಿವರ್ತಿಸಲು ಅನುಮತಿಸಿ.
  • ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು moment-timezone ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ.
• ಕ್ಯಾರೆಕ್ಟರ್ ಎನ್‌ಕೋಡಿಂಗ್:
  • ವಿವಿಧ ಭಾಷೆಗಳ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಕ್ಷರಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಎಲ್ಲಾ ಪಠ್ಯ ಡೇಟಾಗೆ UTF-8 ಎನ್‌ಕೋಡಿಂಗ್ ಬಳಸಿ.
  • ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ ಮತ್ತು ಇತರ ಡೇಟಾ ಸಂಗ್ರಹಣಾ ವ್ಯವಸ್ಥೆಗಳು UTF-8 ಬಳಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಪ್ರವೇಶಸಾಧ್ಯತೆ:
  • ನಿಮ್ಮ API ಅನ್ನು ವಿಕಲಾಂಗ ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶಿಸಲು ಪ್ರವೇಶಸಾಧ್ಯತೆಯ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು (ಉದಾ., WCAG) ಅನುಸರಿಸಿ.
  • ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸ್ಪಷ್ಟ ಮತ್ತು ವಿವರಣಾತ್ಮಕ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ.
  • ನಿಮ್ಮ API ದಸ್ತಾವೇಜಿನಲ್ಲಿ ಸೆಮ್ಯಾಂಟಿಕ್ HTML ಅಂಶಗಳು ಮತ್ತು ARIA ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿ.
• ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮತೆ:
  • ಎಲ್ಲಾ ಬಳಕೆದಾರರಿಗೆ ಅರ್ಥವಾಗದ ಸಾಂಸ್ಕೃತಿಕವಾಗಿ ನಿರ್ದಿಷ್ಟ ಉಲ್ಲೇಖಗಳು, ನುಡಿಗಟ್ಟುಗಳು ಅಥವಾ ಹಾಸ್ಯವನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
  • ಸಂವಹನ ಶೈಲಿಗಳು ಮತ್ತು ಆದ್ಯತೆಗಳಲ್ಲಿನ ಸಾಂಸ್ಕೃತಿಕ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ.
  • ವಿವಿಧ ಸಾಂಸ್ಕೃತಿಕ ಗುಂಪುಗಳ ಮೇಲೆ ನಿಮ್ಮ API ಯ ಸಂಭಾವ್ಯ ಪ್ರಭಾವವನ್ನು ಪರಿಗಣಿಸಿ ಮತ್ತು ಸ್ಟೀರಿಯೊಟೈಪ್‌ಗಳು ಅಥವಾ ಪೂರ್ವಾಗ್ರಹಗಳನ್ನು ಶಾಶ್ವತಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ಡೇಟಾ ಗೌಪ್ಯತೆ ಮತ್ತು ಭದ್ರತೆ:
  • GDPR (ಜನರಲ್ ಡೇಟಾ ಪ್ರೊಟೆಕ್ಷನ್ ರೆಗ್ಯುಲೇಶನ್) ಮತ್ತು CCPA (ಕ್ಯಾಲಿಫೋರ್ನಿಯಾ ಕನ್ಸ್ಯೂಮರ್ ಪ್ರೈವೆಸಿ ಆಕ್ಟ್) ನಂತಹ ಡೇಟಾ ಗೌಪ್ಯತೆ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸಿ.
  • ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ರಕ್ಷಿಸಲು ಬಲವಾದ ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ.
  • ಸಾಗಣೆಯಲ್ಲಿ ಮತ್ತು ಉಳಿದಿರುವಾಗ ಎರಡೂ ಕಡೆ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿ.
  • ಬಳಕೆದಾರರಿಗೆ ತಮ್ಮ ಡೇಟಾದ ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸಿ ಮತ್ತು ಅವರ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಅಳಿಸಲು ಅವರಿಗೆ ಅನುಮತಿಸಿ.
• API ದಸ್ತಾವೇಜನ್ನು:
  • ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಸುಲಭವಾದ ಸಮಗ್ರ ಮತ್ತು ಸುಸಂಘಟಿತ API ದಸ್ತಾವೇಜನ್ನು ಒದಗಿಸಿ.
  • ಸಂವಾದಾತ್ಮಕ API ದಸ್ತಾವೇಜನ್ನು ರಚಿಸಲು Swagger/OpenAPI ನಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸಿ.
  • ವೈವಿಧ್ಯಮಯ ಪ್ರೇಕ್ಷಕರಿಗೆ ಅನುಕೂಲವಾಗುವಂತೆ ಬಹು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಸೇರಿಸಿ.
  • ಹೆಚ್ಚಿನ ಪ್ರೇಕ್ಷಕರನ್ನು ತಲುಪಲು ನಿಮ್ಮ API ದಸ್ತಾವೇಜನ್ನು ಬಹು ಭಾಷೆಗಳಿಗೆ ಅನುವಾದಿಸಿ.
• ದೋಷ ನಿರ್ವಹಣೆ:
  • ನಿರ್ದಿಷ್ಟ ಮತ್ತು ಮಾಹಿತಿಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ. "ಏನೋ ತಪ್ಪಾಗಿದೆ" ಎಂಬಂತಹ ಸಾಮಾನ್ಯ ದೋಷ ಸಂದೇಶಗಳನ್ನು ತಪ್ಪಿಸಿ.
  • ದೋಷದ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸಲು ಪ್ರಮಾಣಿತ HTTP ಸ್ಟೇಟಸ್ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸಿ (ಉದಾಹರಣೆಗೆ, ಕೆಟ್ಟ ವಿನಂತಿಗಾಗಿ 400, ಅನಧಿಕೃತಕ್ಕಾಗಿ 401, ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷಕ್ಕಾಗಿ 500).
  • ಸಮಸ್ಯೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಬಳಸಬಹುದಾದ ದೋಷ ಕೋಡ್‌ಗಳು ಅಥವಾ ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಸೇರಿಸಿ.
  • ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಗಾಗಿ ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ದೋಷಗಳನ್ನು ಲಾಗ್ ಮಾಡಿ.
• ದರ ಮಿತಿಗೊಳಿಸುವಿಕೆ: ನಿಮ್ಮ API ಅನ್ನು ದುರುಪಯೋಗದಿಂದ ರಕ್ಷಿಸಲು ಮತ್ತು ನ್ಯಾಯಯುತ ಬಳಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ದರ ಮಿತಿಗೊಳಿಸುವಿಕೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ.
• ಆವೃತ್ತಿಕರಣ: ಹಿಂದುಳಿದ-ಹೊಂದಾಣಿಕೆಯ ಬದಲಾವಣೆಗಳಿಗೆ ಅವಕಾಶ ನೀಡಲು ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ಮುರಿಯುವುದನ್ನು ತಪ್ಪಿಸಲು API ಆವೃತ್ತಿಕರಣವನ್ನು ಬಳಸಿ.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಇಂಟಿಗ್ರೇಷನ್ ನಿಮ್ಮ ಬ್ಯಾಕೆಂಡ್ API ಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಮತ್ತು ಮಿಡಲ್‌ವೇರ್‌ನಲ್ಲಿ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಮುಂಚಿತವಾಗಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಬಹುದು ಮತ್ತು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ API ಸ್ಥಿರವಾದ ಡೇಟಾ ರಚನೆಗೆ ಬದ್ಧವಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೀರಿ, ಇದು ರನ್‌ಟೈಮ್ ದೋಷಗಳ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು ಸ್ಟ್ರಿಕ್ಟ್ ಮೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು, ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಟೈಪ್ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಬಳಸುವುದು, ಮತ್ತು ಯೂನಿಟ್ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವಂತಹ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿಗೆ ಬದ್ಧರಾಗಿರಲು ಮರೆಯದಿರಿ. ನಿಮ್ಮ APIಗಳು ವಿಶ್ವಾದ್ಯಂತ ಪ್ರವೇಶಿಸಬಲ್ಲ ಮತ್ತು ಬಳಸಬಲ್ಲವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯಾವಾಗಲೂ ಸ್ಥಳೀಕರಣ, ಸಮಯ ವಲಯಗಳು ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮತೆಯಂತಹ ಜಾಗತಿಕ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ.